home *** CD-ROM | disk | FTP | other *** search
/ CD ROM Paradise Collection 4 / CD ROM Paradise Collection 4 1995 Nov.iso / program / recio212.zip / testchg.c < prev    next >
C/C++ Source or Header  |  1995-01-29  |  10KB  |  300 lines
  1. /* testchg.c - tests character delimited get functions */
  2. /* recio version 2.12, release January 29, 1995 */
  3. /* Copyright (C) 1994-1995, William Pierpoint */
  4.  
  5. #include <ctype.h>
  6. #include <errno.h>
  7. #include <limits.h>
  8. #include <float.h>
  9. #include <stdio.h>
  10. #include <stdlib.h>
  11. #include <string.h>
  12. #include <time.h>
  13.  
  14. #include "recio.h"
  15.  
  16. /* errors normally to stderr; but for test purposes, stdout */
  17. #define errout  stdout
  18.  
  19. /****************************************************************************/
  20. void                         /* return nothing                              */
  21.     rfixnum(                 /* fix number                                  */
  22.         REC *rp,             /* record pointer                              */
  23.         int  errnum,         /* error number                                */
  24.         void (*rfix)(REC *)) /* rfix function pointer                       */
  25. /****************************************************************************/
  26. {
  27.   switch (errnum) {
  28.   case R_EMISDAT:
  29.     fprintf(errout, "...substituting zero\n");
  30.     rsetfldstr(rp, "0");
  31.     break;
  32.   case R_EINVDAT:
  33.   case R_ERANGE:
  34.     fprintf(errout, "...substituting best guess\n");
  35.     rfix(rp);
  36.     break;
  37.   }
  38. }
  39.  
  40. /****************************************************************************/
  41. void                         /* return nothing                              */
  42.     rfixtime(                /* fix time                                   */
  43.         REC *rp,             /* record pointer                              */
  44.         int  errnum,         /* error number                                */
  45.         void (*rfix)(REC *)) /* rfix function pointer                       */
  46. /****************************************************************************/
  47. {
  48.   switch (errnum) {
  49.   case R_EMISDAT:
  50.     fprintf(errout, "...substituting 1/1/70 00:00:00\n");
  51.     rsetfldstr(rp, "1/1/70 0:0:0");
  52.     break;
  53.   case R_EINVDAT:
  54.   case R_ERANGE:
  55.     fprintf(errout, "...substituting best guess\n");
  56.     rfix(rp);
  57.     break;
  58.   }
  59. }
  60.  
  61. /****************************************************************************/
  62. void                         /* return nothing                              */
  63.     rfixchar(                /* fix character                               */
  64.         REC *rp,             /* record pointer                              */
  65.         int  errnum,         /* error number                                */
  66.         void (*rfix)(REC *)) /* rfix function pointer                       */
  67. /****************************************************************************/
  68. {
  69.   switch (errnum) {
  70.   case R_EMISDAT:
  71.     fprintf(errout, "...substituting the letter N\n");
  72.     rsetfldstr(rp, "N");
  73.     break;
  74.   case R_EINVDAT:
  75.     fprintf(errout, "...substituting best guess\n");
  76.     rfix(rp);
  77.     break;
  78.   }
  79. }
  80.  
  81. /****************************************************************************/
  82. void                         /* returns nothing                             */
  83.     rwarnfn(                 /* recio callback warning function             */
  84.         REC *rp)             /* record pointer                              */
  85. /****************************************************************************/
  86. {
  87.   if (risvalid(rp)) {
  88.     switch (rwarning(rp)) {
  89.     case R_WNOREG:   /* atexit() full */
  90.       fprintf (errout, "WARNING %s\n", rwarnstr(rp));
  91.       break;
  92.     case R_WEMPSTR:  /* empty data string */
  93.     case R_WTMFMT:   /* time data incomplete */
  94.       fprintf(errout, "WARNING reading %s at record %lu and field %u -- %s\n", 
  95.        rnames(rp), rrecno(rp), rfldno(rp), rwarnstr(rp));
  96.       break;
  97.     }
  98.   }
  99. }
  100.  
  101. /****************************************************************************/
  102. void                         /* returns nothing                             */
  103.      errnofn(                /* errno callback error function               */
  104.         void)                /* no parameters                               */
  105. /****************************************************************************/
  106. {
  107.   switch (errno) {
  108.  
  109.   /* non-fatal errors */
  110.   case EACCES:
  111.   case EMFILE:
  112.     fprintf(errout, "ERROR: %s\n", strerror(errno));
  113.     break;
  114.  
  115.   /* fatal errors (EINVAL, ENOMEM) */
  116.   default:
  117.     fprintf(errout, "FATAL ERROR: %s\n", strerror(errno));
  118.     abort();
  119.     break;
  120.   }
  121. }
  122.  
  123. /****************************************************************************/
  124. void                         /* returns nothing                             */
  125.     rerrfn(                  /* recio callback error function               */
  126.         REC *rp)             /* record pointer                              */
  127. /****************************************************************************/
  128. {
  129.   int errnum;       /* error number */
  130.  
  131.   if (risvalid(rp)) {
  132.   
  133.     /* if reof indicator set */
  134.     if (reof(rp)) { 
  135.       fprintf(errout, "ERROR reading %s: "
  136.        "tried to read past end of file\n", rnames(rp));
  137.     
  138.     /* else rerror indicator set */
  139.     } else {
  140.  
  141.       /* determine cause of error */
  142.       errnum = rerror(rp);
  143.       switch (errnum) {
  144.  
  145.       /* data errors */
  146.       case R_ERANGE:   /* data out of range */
  147.       case R_EINVDAT:  /* invalid data */
  148.       case R_EMISDAT:  /* missing data */
  149.         fprintf(errout, "DATA ERROR reading %s at record %lu and field %u "
  150.          "-- %s\n", rnames(rp), rrecno(rp), rfldno(rp), rerrstr(rp));
  151.           
  152.         /* determine context */
  153.         switch (rcxtno(rp)) {
  154.         case RECIN:
  155.           
  156.           /* determine field */
  157.           switch (rfldno(rp)) {
  158.           case 1:  /* the integer field i */
  159.             rfixnum(rp, errnum, rfixi);
  160.             break;
  161.           
  162.           case 2:  /* the unsigned integer field ui */
  163.             rfixnum(rp, errnum, rfixui);
  164.             break;
  165.  
  166.            case 3:  /* the long field l */
  167.             rfixnum(rp, errnum, rfixl);
  168.             break;
  169.  
  170.            case 4:  /* the unsigned long field ul */
  171.             rfixnum(rp, errnum, rfixul);
  172.             break;
  173.  
  174.            case 5:  /* the float field f */
  175.             rfixnum(rp, errnum, rfixf);
  176.             break;
  177.  
  178.           case 6:  /* the double field d */
  179.             rfixnum(rp, errnum, rfixd);
  180.             break;
  181.  
  182.           case 7: /* the character field ch */
  183.             rfixchar(rp, errnum, rfixc);
  184.             break;
  185.  
  186.           case 9: /* the time field t */
  187.             rfixtime(rp, errnum, rfixt);
  188.             break;
  189.  
  190.           default: /* programming error - no case for field */
  191.             fprintf(errout, "FATAL ERROR %s -- code missing for field %u\n",
  192.              rnames(rp), rfldno(rp));
  193.             abort();
  194.             break;
  195.           }
  196.           break;
  197.         
  198.         default:  /* programming error - missing context number */
  199.           fprintf (errout, "FATAL ERROR %s -- missing context number\n", 
  200.            rnames(rp));
  201.           abort();
  202.           break;
  203.         }
  204.         break;
  205.         
  206.       /* fatal errors (R_EINVMOD, R_EINVAL, R_ENOMEM) */
  207.       default:
  208.         fprintf(errout, "FATAL ERROR %s -- %s\n", rnames(rp), rerrstr(rp));
  209.         abort();
  210.         break;
  211.       }
  212.     }
  213.   
  214.   /* invalid record pointer */
  215.   } else {
  216.     errnofn();
  217.   }
  218. }
  219.  
  220. /****************************************************************************
  221. main
  222. *****************************************************************************/
  223. #include <io.h>
  224.  
  225. int main()
  226. {
  227.   int i;                        /* integer field */
  228.   unsigned int ui;              /* unsigned integer field */
  229.   long l;                       /* long field */
  230.   unsigned long ul;             /* unsigned long field */
  231.   float f;                      /* float field */
  232.   double d;                     /* double field */
  233.   int ch;                       /* character field */
  234.   char *str = NULL;             /* string field */
  235.   time_t t;                     /* time field */
  236.   
  237.   /* install error and warning functions */
  238.   rinit(rerrfn, rwarnfn);
  239.   
  240.   /* set field and text delimiters */
  241.   rsetfldch(recin, ',');
  242.   rsettxtch(recin, '"');
  243.   rsettmfmt(recin, "%m/%d/%y %H:%M:%S");
  244.   
  245.   /* if input not redirected */
  246.   if (isatty(fileno(stdin))) {
  247.     /* print instructions */
  248.     puts("TESTCHG version 2.12 Copyright (C) 1994-1995, William Pierpoint");
  249.     puts("Tests recio character delimited get functions.");
  250.     puts("It reads nine fields, separated by commas, from the console.");
  251.     puts("The field types are: int, unsigned int, long, unsigned long,");
  252.     puts("                     float, double, character, string, and time\n");
  253.     puts("Example:");
  254.     puts("-1,1,-99999,99999,3.14159,3.14159265,Y,\"Hello\",11/1/94 12:00:00\n");
  255.     puts("Press Ctrl-Z followed by the Enter key to exit program.");
  256.     puts("You may begin now.\n");
  257.   }
  258.   
  259.   /* loop through input */
  260.   while (rgetrec(recin)) {
  261.  
  262.     /* if input redirected, echo record contents */
  263.     if (!isatty(fileno(stdin))) puts(rrecs(recin));
  264.  
  265.     /* parse record */
  266.     i   = rgeti(recin);
  267.     ui  = rgetui(recin);
  268.     l   = rgetl(recin);
  269.     ul  = rgetul(recin);
  270.     f   = rgetf(recin);
  271.     d   = rgetd(recin);
  272.     ch  = rgetc(recin);
  273.     scpys(str, rgets(recin));
  274.     t   = rgett(recin);
  275.     
  276.     /* print results */
  277.     printf("\n");
  278.     printf("         Integer field: %d\n", i);
  279.     printf("Unsigned Integer field: %u\n", ui);
  280.     printf("            Long field: %ld\n", l);
  281.     printf("   Unsigned Long field: %lu\n", ul);
  282.     printf("           Float field: %.*e\n", FLT_DIG-1, f);
  283.     printf("          Double field: %.*e\n", DBL_DIG-1, d);
  284.     printf("       Character field: %c\n", ch);
  285.     printf("          String field: %s\n", str);
  286.     printf("            Time field: %s\n\n", ctime(&t));
  287.   }
  288.   
  289.   /* free dynamic string fields */
  290.   free (str);
  291.   
  292.   /* check stream for error */
  293.   if (rerror(recin)) { 
  294.     fprintf(errout, "ERROR reading %s: %s\n", 
  295.      rnames(recin), rerrstr(recin));
  296.     exit (EXIT_FAILURE);
  297.   }
  298.   return EXIT_SUCCESS;
  299. }
  300.